/**
 * Kimi大模型API适配器
 */
import { AI_MODEL_CONFIG } from '../config/ai-config';
import { KIMI_API_KEY, validateApiKey, getApiKey } from './kimi-key';

// Kimi API配置
const KIMI_CONFIG = {
  apiUrl: 'https://api.moonshot.cn/v1/chat/completions',
  apiVersion: 'v1',
  defaultModel: 'moonshot-v1-8k',
  defaultMaxTokens: 1000
};

/**
 * 发送请求到Kimi API
 * @param {String} query 用户问题
 * @param {Array} history 历史消息
 * @param {Object} options 可选配置
 * @returns {Promise<Object>} Kimi API响应
 */
export async function sendKimiRequest(query, history = [], options = {}) {
  // 获取并验证API密钥
  const apiKey = options.apiKey || getApiKey();
  if (!validateApiKey(apiKey)) {
    return {
      success: false,
      error: '无效的API密钥，请在设置中配置正确的API密钥',
      errorType: 'INVALID_API_KEY'
    };
  }
  
  // 构建请求头
  const headers = {
    'Content-Type': 'application/json',
    'Authorization': `Bearer ${apiKey}`
  };
  
  // 构建消息历史
  const messages = formatChatHistory(history);
  
  // 添加用户当前问题
  messages.push({
    role: 'user',
    content: query
  });
  
  // 添加系统提示语（如果有）
  if (AI_MODEL_CONFIG.systemPrompt && !options.skipSystemPrompt) {
    messages.unshift({
      role: 'system',
      content: AI_MODEL_CONFIG.systemPrompt
    });
  }
  
  // 构建请求体
  const requestBody = {
    model: options.model || KIMI_CONFIG.defaultModel,
    messages: messages,
    temperature: options.temperature || AI_MODEL_CONFIG.temperature,
    max_tokens: options.maxTokens || KIMI_CONFIG.defaultMaxTokens,
    stream: false, // 不使用流式响应
    name: "百善家政AI助手" // 添加name字段，这是Kimi API必需的
  };
  
  console.log('Kimi请求参数:', JSON.stringify(requestBody));
  
  try {
    // 设置更短的超时时间，避免长时间等待
    const timeout = options.timeout || 20000; // 默认20秒
    
    console.log(`开始发送Kimi请求，超时时间: ${timeout}ms`);
    const startTime = Date.now();
    
    // 发送请求到Kimi API
    const response = await uni.request({
      url: KIMI_CONFIG.apiUrl,
      method: 'POST',
      header: headers,
      data: requestBody,
      timeout: timeout
    });
    
    const endTime = Date.now();
    console.log(`Kimi响应状态: ${response.statusCode}, 耗时: ${endTime - startTime}ms`);
    
    // 检查响应状态
    if (response.statusCode === 200 && response.data) {
      console.log('Kimi响应成功，开始处理响应数据');
      const answer = extractKimiResponse(response.data);
      console.log('提取的回答:', answer.substring(0, 50) + (answer.length > 50 ? '...' : ''));
      
      return {
        success: true,
        answer: answer,
        rawResponse: response.data
      };
    } else if (response.statusCode === 401) {
      // API密钥无效
      console.error('Kimi认证失败: 401 Unauthorized');
      clearKimiApiKey(); // 清除无效的API密钥
      return {
        success: false,
        error: 'API密钥无效或已过期，请更新API密钥',
        errorType: 'INVALID_API_KEY'
      };
    } else if (response.statusCode === 422) {
      // 请求参数错误
      console.error('Kimi请求参数错误:', response.data);
      return {
        success: false,
        error: '请求参数错误: ' + (response.data?.error?.message || '参数格式不正确'),
        errorType: 'INVALID_PARAMS'
      };
    } else if (response.statusCode === 429) {
      // 请求过于频繁
      return {
        success: false,
        error: '请求过于频繁，请稍后再试',
        errorType: 'RATE_LIMIT'
      };
    } else {
      console.error('Kimi请求失败，状态码:', response.statusCode, '响应数据:', response.data);
      throw new Error(response.data?.error?.message || `请求失败，状态码: ${response.statusCode}`);
    }
  } catch (error) {
    console.error('Kimi API请求失败:', error);
    
    // 根据错误类型返回不同的错误信息
    if (error.errMsg && error.errMsg.includes('timeout')) {
      console.error('Kimi请求超时');
      return {
        success: false,
        error: '请求超时，请检查网络连接',
        errorType: 'TIMEOUT'
      };
    } else if (error.errMsg && error.errMsg.includes('fail')) {
      console.error('Kimi网络连接失败');
      return {
        success: false,
        error: '网络连接失败，请检查网络设置',
        errorType: 'NETWORK_ERROR'
      };
    }
    
    return {
      success: false,
      error: error.message || '未知错误',
      errorType: 'UNKNOWN',
      rawError: error
    };
  }
}

/**
 * 从Kimi响应中提取回答文本
 * @param {Object} response Kimi API响应
 * @returns {String} 回答文本
 */
function extractKimiResponse(response) {
  try {
    if (response.choices && response.choices.length > 0) {
      return response.choices[0].message.content || '';
    }
    return '抱歉，无法获取有效回复。';
  } catch (error) {
    console.error('提取Kimi响应失败:', error);
    return '抱歉，解析回复时出错。';
  }
}

/**
 * 格式化聊天历史为Kimi API所需格式
 * @param {Array} history 聊天历史记录
 * @returns {Array} 格式化后的消息数组
 */
function formatChatHistory(history) {
  if (!history || !Array.isArray(history) || history.length === 0) {
    return [];
  }
  
  return history.map(msg => ({
    role: msg.type === 'user' ? 'user' : 'assistant',
    content: msg.content
  }));
}

/**
 * 获取Kimi API密钥
 * @returns {String} API密钥
 */
function getKimiApiKey() {
  return getApiKey();
}

/**
 * 保存Kimi API密钥到本地存储
 * @param {String} apiKey API密钥
 * @returns {Boolean} 是否保存成功
 */
export function saveKimiApiKey(apiKey) {
  if (validateApiKey(apiKey)) {
    uni.setStorageSync('kimi_api_key', apiKey);
    return true;
  }
  return false;
}

/**
 * 清除保存的Kimi API密钥
 */
export function clearKimiApiKey() {
  uni.removeStorageSync('kimi_api_key');
}

/**
 * 检查是否已配置Kimi API密钥
 * @returns {Boolean} 是否已配置API密钥
 */
export function hasKimiApiKey() {
  const apiKey = getKimiApiKey();
  return !!apiKey && apiKey.length > 10;
}

export default {
  sendKimiRequest,
  saveKimiApiKey,
  clearKimiApiKey,
  hasKimiApiKey,
  KIMI_CONFIG
}; 